

class 流动性大杂烩择时():
    strategy_name = '流动性大杂烩择时'  # 当前账户运行策略的名称。可以自己任意取
    strategy_config = {
        'name': 'FixedRatioStrategy',  # *必填。使用什么策略，这里是轮动策略
        'hold_period': '24H',  # *必填。聚合后策略持仓周期。目前回测支持日线级别、小时级别。例：1H，6H，3D，7D......
        'params': {
            'cap_ratios': [1 / 2, 1 / 2]
        }
    }
    # 策略池
    strategy_pool = [
        # 流动性多头
        dict(
            name='流动性多头大杂烩（择时MA5x24）',
            strategy_list=[
                {
                    # 策略名称。与strategy目录中的策略文件名保持一致。
                    "strategy": "Strategy_流动性多头",
                    "offset_list": range(0, 24, 6),
                    "hold_period": "24H",
                    "is_use_spot": True,
                    # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                    'cap_weight': 1,
                    'long_cap_weight': 1,
                    'short_cap_weight': 1,
                    'long_select_coin_num': x,
                    'short_select_coin_num': 'long_nums',
                    # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                    "factor_list": [
                        (y, True, z, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                    ],
                    "filter_list": [
                        ('PctChange', z, 'pct:<0.8')
                    ],
                    "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                }
                for x in [0.1] for y in ['QuoteVolumeMean'] for z in [48, 96, 192, 384, 768]
            ],
            re_timing={'name': 'MovingAverage', 'params': [5 * 24]}  # 可选，配置再择时策略
        ),
        dict(
            name='流动性多头大杂烩（择时MA55x24）',
            strategy_list=[
                {
                    # 策略名称。与strategy目录中的策略文件名保持一致。
                    "strategy": "Strategy_流动性多头",
                    "offset_list": range(0, 24, 6),
                    "hold_period": "24H",
                    "is_use_spot": True,
                    # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                    'cap_weight': 1,
                    'long_cap_weight': 1,
                    'short_cap_weight': 1,
                    'long_select_coin_num': x,
                    'short_select_coin_num': 'long_nums',
                    # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                    "factor_list": [
                        (y, True, z, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                    ],
                    "filter_list": [
                        ('PctChange', z, 'pct:<0.8')
                    ],
                    "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                }
                for x in [0.1] for y in ['QuoteVolumeMean'] for z in [48, 96, 192, 384, 768]
            ],
            re_timing={'name': 'MovingAverage', 'params': [55 * 24]}  # 可选，配置再择时策略
        )
    ]


class 轮动策略Bias6默认策略():
    backtest_name = '轮动策略Bias6'  # 回测的策略组合的名称。可以自己任意取。一般建议，一个回测组，就是实盘中的一个账户。
    strategy_config = {
        'name': 'RotationStrategy',  # *必填。使用什么策略，这里是轮动策略
        'hold_period': '24H',  # *必填。聚合后策略持仓周期。目前回测支持日线级别、小时级别。例：1H，6H，3D，7D......
        'params': {  # 非必填。聚合类策略的参数，这里的案例是在轮动策略场景下，我们需要提供轮动因子。
            'factor_list': [
                ('Bias', False, 6, 1),
            ]
        }
    }
    strategy_pool = [
        dict(
            name='流动性多空大杂烩',
            strategy_list=[
                {
                    "strategy": "流动性多空",
                    "offset_list": range(0, 24, 1),
                    "hold_period": "24H",
                    "is_use_spot": True,
                    'cap_weight': 1,
                    'long_cap_weight': 1,
                    'short_cap_weight': 0,
                    'long_select_coin_num': x,
                    'short_select_coin_num': 0,
                    "factor_list": [
                        (y, True, z, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                    ],
                    "filter_list": [
                        ('PctChange', z, 'pct:<0.8')
                    ],
                    "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                } for x in [0.1] for y in ['ILLQStd', 'ILLQMean'] for z in
                [48, 96, 192]
            ]
        ),
        dict(
            name='流动性多头大杂烩',
            strategy_list=[
                {
                    "strategy": "流动性多头",
                    "offset_list": range(0, 24, 1),
                    "hold_period": "24H",
                    "is_use_spot": True,
                    'cap_weight': 1,
                    'long_cap_weight': 1,
                    'short_cap_weight': 1,
                    'long_select_coin_num': x,
                    'short_select_coin_num': 'long_nums',
                    "factor_list": [
                        (y, True, z, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                    ],
                    "filter_list": [
                        ('PctChange', z, 'pct:<0.8')
                    ],
                    "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                } for x in [0.1] for y in ['ILLQStd', 'ILLQMean'] for z in
                [48, 96, 192]
            ],
        ),
    ]


class 多参数轮动流动性动量混合():
    strategy_name = '多参数轮动流动性动量混合'  # 当前账户运行策略的名称。可以自己任意取
    strategy_config = {
        'name': 'RotationStrategy',  # *必填。使用什么策略，这里是轮动策略
        'hold_period': '1H',  # *必填。聚合后策略持仓周期。目前回测支持日线级别、小时级别。例：1H，6H，3D，7D......
        'params': {  # 非必填。聚合类策略的参数，这里的案例是在轮动策略场景下，我们需要提供轮动因子。
            'factor_list': [
                ('BiasPct', False, 168, 1),
                ('BiasPct', False, 42, 1),
                ('BiasMean', False, 126, 1),
            ]
        }
    }
    # 策略池
    strategy_pool = [
        dict(
            name='流动性纯多大杂烩',
            strategy_list=[
                              {
                                  "strategy": "流动性纯多",
                                  "offset_list": range(0, 24, 1),
                                  "hold_period": "24H",
                                  "is_use_spot": True,
                                  'cap_weight': 1,
                                  'long_cap_weight': 1,
                                  'short_cap_weight': 0,
                                  'long_select_coin_num': x,
                                  'short_select_coin_num': 0,
                                  "factor_list": [
                                      (y, True, z, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                                  ],
                                  "filter_list": [
                                      ('PctChange', z, 'pct:<0.8')
                                  ],
                                  "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                              } for x in [0.2] for y in ['ILLQStd'] for z in
                              [384, 768, 1536, 2072]
                          ] + [
                              # === 多1动量
                              {
                                  # 策略名称。与strategy目录中的策略文件名保持一致。
                                  "strategy": "Strategy_多1动量",
                                  "offset_list": list(range(0, 1, 1)),
                                  "hold_period": "1H",
                                  "is_use_spot": False,
                                  # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                                  'cap_weight': 0.5,
                                  'long_cap_weight': 1,
                                  'short_cap_weight': 0,
                                  # 选币数量
                                  'long_select_coin_num': 1,
                                  'short_select_coin_num': 0,
                                  # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                                  "factor_list": [
                                      ('动量因子1', False, 1440, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                                  ],
                                  "filter_list": [
                                      ('ILLQStd', 1440, 'pct:>0.8', True)
                                  ],
                                  "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                              },
                              {
                                  # 策略名称。与strategy目录中的策略文件名保持一致。
                                  "strategy": "Strategy_多1动量",
                                  "offset_list": list(range(0, 1, 1)),
                                  "hold_period": "1H",
                                  "is_use_spot": False,
                                  # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                                  'cap_weight': 0.5,
                                  'long_cap_weight': 1,
                                  'short_cap_weight': 0,
                                  # 选币数量
                                  'long_select_coin_num': 1,
                                  'short_select_coin_num': 0,
                                  # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                                  "factor_list": [
                                      ('动量因子1', False, 1680, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                                  ],
                                  "filter_list": [
                                      ('ILLQStd', 1680, 'pct:>0.8', True)
                                  ],
                                  "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                              },
                          ]
        ),
        dict(
            name='混合策略',
            strategy_list=[
                              # === 流动性多空
                              {
                                  # 策略名称。与strategy目录中的策略文件名保持一致。
                                  "strategy": "Strategy_保三",
                                  "offset_list": range(0, 24, 1),
                                  "hold_period": "24H",
                                  "is_use_spot": True,
                                  # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                                  'cap_weight': 0.8 / 7,
                                  'long_cap_weight': 1,
                                  'short_cap_weight': 1,
                                  'long_select_coin_num': x,
                                  'short_select_coin_num': 'long_nums',
                                  # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                                  "factor_list": [
                                      (y, True, z, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                                  ],
                                  "filter_list": [
                                      ('PctChange', z, 'pct:<0.8')
                                  ],
                                  "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                              } for x in [0.2] for y in ['ILLQStd'] for z in
                              [96, 192, 384, 768, 1536, 2072]
                          ] + [
                              # === 多1空1动量
                              # = MtmMean
                              {
                                  # 策略名称。与strategy目录中的策略文件名保持一致。
                                  "strategy": "Strategy_多1空1动量",
                                  "offset_list": list(range(0, 1, 1)),
                                  "hold_period": "1H",
                                  "is_use_spot": False,
                                  # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                                  'cap_weight': 0.1 / 3 / 2,
                                  'long_cap_weight': 1,
                                  'short_cap_weight': 1,
                                  'long_select_coin_num': 1,
                                  'short_select_coin_num': 1,
                                  # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                                  "factor_list": [
                                      ('MtmMean', False, 30, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                                  ],
                                  "filter_list": [
                                      ('PctChangeMax', 24, 'val:<0.2'),
                                      ('VolumeSum', 24, 'rank:<50', False),
                                  ],
                                  "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                              },
                              {
                                  # === 多1空1动量
                                  # 策略名称。与strategy目录中的策略文件名保持一致。
                                  "strategy": "Strategy_多1空1动量",
                                  "offset_list": list(range(0, 1, 1)),
                                  "hold_period": "1H",
                                  "is_use_spot": False,
                                  # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                                  'cap_weight': 0.1 / 3 / 2,
                                  'long_cap_weight': 1,
                                  'short_cap_weight': 1,
                                  'long_select_coin_num': 1,
                                  'short_select_coin_num': 1,
                                  # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                                  "factor_list": [
                                      ('MtmMean', False, 100, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                                  ],
                                  "filter_list": [
                                      ('PctChangeMax', 24, 'val:<0.2'),
                                      ('VolumeSum', 24, 'rank:<50', False),
                                  ],
                                  "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                              },

                              # = 动量111
                              {
                                  # 策略名称。与strategy目录中的策略文件名保持一致。
                                  "strategy": "Strategy_多1空1动量",
                                  "offset_list": list(range(0, 1, 1)),
                                  "hold_period": "1H",
                                  "is_use_spot": False,
                                  # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                                  'cap_weight': 0.1 / 3 / 2,
                                  'long_cap_weight': 1,
                                  'short_cap_weight': 1,
                                  'long_select_coin_num': 1,
                                  'short_select_coin_num': 1,
                                  # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                                  "factor_list": [
                                      ('111', False, 25, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                                  ],
                                  "filter_list": [
                                      ('PctChangeMax', 24, 'val:<0.2'),
                                      ('VolumeSum', 24, 'rank:<50', False),
                                  ],
                                  "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                              },
                              {
                                  # 策略名称。与strategy目录中的策略文件名保持一致。
                                  "strategy": "Strategy_多1空1动量",
                                  "offset_list": list(range(0, 1, 1)),
                                  "hold_period": "1H",
                                  "is_use_spot": False,
                                  # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                                  'cap_weight': 0.1 / 3 / 2,
                                  'long_cap_weight': 1,
                                  'short_cap_weight': 1,
                                  'long_select_coin_num': 1,
                                  'short_select_coin_num': 1,
                                  # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                                  "factor_list": [
                                      ('111', False, 135, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                                  ],
                                  "filter_list": [
                                      ('PctChangeMax', 24, 'val:<0.2'),
                                      ('VolumeSum', 24, 'rank:<50', False),
                                  ],
                                  "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                              },

                              # = BiasEma
                              {
                                  # 策略名称。与strategy目录中的策略文件名保持一致。
                                  "strategy": "Strategy_多1空1动量",
                                  "offset_list": list(range(0, 1, 1)),
                                  "hold_period": "1H",
                                  "is_use_spot": False,
                                  # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                                  'cap_weight': 0.1 / 3 / 2,
                                  'long_cap_weight': 1,
                                  'short_cap_weight': 1,
                                  'long_select_coin_num': 1,
                                  'short_select_coin_num': 1,
                                  # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                                  "factor_list": [
                                      ('BiasEma', False, 25, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                                  ],
                                  "filter_list": [
                                      ('PctChangeMax', 24, 'val:<0.2'),
                                      ('VolumeSum', 24, 'rank:<50', False),
                                  ],
                                  "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                              },
                              {
                                  # 策略名称。与strategy目录中的策略文件名保持一致。
                                  "strategy": "Strategy_多1空1动量",
                                  "offset_list": list(range(0, 1, 1)),
                                  "hold_period": "1H",
                                  "is_use_spot": False,
                                  # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                                  'cap_weight': 0.1 / 3 / 2,
                                  'long_cap_weight': 1,
                                  'short_cap_weight': 1,
                                  'long_select_coin_num': 1,
                                  'short_select_coin_num': 1,
                                  # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                                  "factor_list": [
                                      ('BiasEma', False, 65, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                                  ],
                                  "filter_list": [
                                      ('PctChangeMax', 24, 'val:<0.2'),
                                      ('VolumeSum', 24, 'rank:<50', False),
                                  ],
                                  "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                              }
                          ] + [
                              # === 多1动量
                              {
                                  # 策略名称。与strategy目录中的策略文件名保持一致。
                                  "strategy": "Strategy_多1动量",
                                  "offset_list": list(range(0, 1, 1)),
                                  "hold_period": "1H",
                                  "is_use_spot": False,
                                  # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                                  'cap_weight': 0.05,
                                  'long_cap_weight': 1,
                                  'short_cap_weight': 0,
                                  # 选币数量
                                  'long_select_coin_num': 1,
                                  'short_select_coin_num': 0,
                                  # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                                  "factor_list": [
                                      ('动量因子1', False, 1440, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                                  ],
                                  "filter_list": [
                                      ('ILLQStd', 1440, 'pct:>0.8', True)
                                  ],
                                  "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                              },
                              {
                                  # 策略名称。与strategy目录中的策略文件名保持一致。
                                  "strategy": "Strategy_多1动量",
                                  "offset_list": list(range(0, 1, 1)),
                                  "hold_period": "1H",
                                  "is_use_spot": False,
                                  # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                                  'cap_weight': 0.05,
                                  'long_cap_weight': 1,
                                  'short_cap_weight': 0,
                                  # 选币数量
                                  'long_select_coin_num': 1,
                                  'short_select_coin_num': 0,
                                  # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                                  "factor_list": [
                                      ('动量因子1', False, 1680, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                                  ],
                                  "filter_list": [
                                      ('ILLQStd', 1680, 'pct:>0.8', True)
                                  ],
                                  "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                              },
                          ],
        ),
    ]

class 轮动策略我的实盘策略():
    backtest_name = '轮动策略Bias6'  # 回测的策略组合的名称。可以自己任意取。一般建议，一个回测组，就是实盘中的一个账户。
    strategy_config = {
        'name': 'RotationStrategy',  # *必填。使用什么策略，这里是轮动策略
        'hold_period': '24H',  # *必填。聚合后策略持仓周期。目前回测支持日线级别、小时级别。例：1H，6H，3D，7D......
        'params': {  # 非必填。聚合类策略的参数，这里的案例是在轮动策略场景下，我们需要提供轮动因子。
            'factor_list': [
                #('Bias', False, 6, 1),
                ('Bias', False, 5, 1),
            ]
        }
    }
    strategy_pool = [
        dict(
            name='流动性多头大杂烩',
            strategy_list=[
                {
                    "strategy": "流动性多头",
                    "offset_list": [9,10,11,12,13,14],
                    "hold_period": "24H",
                    "is_use_spot": True,
                    'cap_weight': 1,
                    'long_cap_weight': 1,
                    'short_cap_weight': 0,
                    'long_select_coin_num': x,
                    'short_select_coin_num': 0,
                    "factor_list": [
                        (y, True, z, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                    ],
                    "filter_list": [
                        ('PctChange', z, 'pct:<0.8')
                    ],
                    "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                } for x in [0.2] for y in ['ILLQStd', 'ILLQMean'] for z in
                [48,96,192,768]
            ]+[
                # === 多1空1动量
                {
                    # 策略名称。与strategy目录中的策略文件名保持一致。
                    "strategy": "Strategy_多1空1动量",
                    "offset_list": list(range(0, 1, 1)),
                    "hold_period": "1H",
                    "is_use_spot": False,
                    # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                    'cap_weight': 0.3,
                    'long_cap_weight': 1,
                    'short_cap_weight': 0,
                    'long_select_coin_num': 1,
                    'short_select_coin_num': 1,
                    # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                    "factor_list": [
                        ('MtmMean', False, 30, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                    ],
                    "filter_list": [
                        ('涨跌幅max', 24, 'val:<=0.2'),  # 因子名（和factors文件中相同），参数
                        ('Volume', 24, 'rank:<=60', False),
                    ],
                    "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                },
                {
                    # === 多1空1动量
                    # 策略名称。与strategy目录中的策略文件名保持一致。
                    "strategy": "Strategy_多1空1动量",
                    "offset_list": list(range(0, 1, 1)),
                    "hold_period": "1H",
                    "is_use_spot": False,
                    # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                    'cap_weight': 0.3,
                    'long_cap_weight': 1,
                    'short_cap_weight': 0,
                    'long_select_coin_num': 1,
                    'short_select_coin_num': 1,
                    # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                    "factor_list": [
                        ('MtmMean', False, 100, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                    ],
                    "filter_list": [
                        ('涨跌幅max', 24, 'val:<=0.2'),  # 因子名（和factors文件中相同），参数
                        ('Volume', 24, 'rank:<=60', False),
                    ],
                    "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                },

                # === 多1动量
                {
                    # 策略名称。与strategy目录中的策略文件名保持一致。
                    "strategy": "Strategy_多1动量",
                    "offset_list": list(range(0, 1, 1)),
                    "hold_period": "1H",
                    "is_use_spot": False,
                    # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                    'cap_weight': 0.3,
                    'long_cap_weight': 1,
                    'short_cap_weight': 0,
                    # 选币数量
                    'long_select_coin_num': 1,
                    'short_select_coin_num': 0,
                    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                    "factor_list": [
                        ('动量因子1', False, 1440, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                    ],
                    "filter_list": [
                        ('ILLQStd', 1440, 'pct:>0.8', True)
                    ],
                    "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                },
                {
                    # 策略名称。与strategy目录中的策略文件名保持一致。
                    "strategy": "Strategy_多1动量",
                    "offset_list": list(range(0, 1, 1)),
                    "hold_period": "1H",
                    "is_use_spot": False,
                    # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                    'cap_weight': 0.3,
                    'long_cap_weight': 1,
                    'short_cap_weight': 0,
                    # 选币数量
                    'long_select_coin_num': 1,
                    'short_select_coin_num': 0,
                    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                    "factor_list": [
                        ('动量因子1', False, 1680, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                    ],
                    "filter_list": [
                        ('ILLQStd', 1680, 'pct:>0.8', True)
                    ],
                    "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                },
            ]
        ),
        dict(
            name='流动性多空大杂烩',
            strategy_list=[
                {
                    "strategy": "流动性多空",
                    "offset_list": [9,10,11,12,13,14],
                    "hold_period": "24H",
                    "is_use_spot": True,
                    'cap_weight': 1,
                    'long_cap_weight': 1,
                    'short_cap_weight': 1,
                    'long_select_coin_num': x,
                    'short_select_coin_num': 'long_nums',
                    "factor_list": [
                        (y, True, z, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                    ],
                    "filter_list": [
                        ('PctChange', z, 'pct:<0.8')
                    ],
                    "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                } for x in [0.2] for y in ['ILLQStd', 'ILLQMean'] for z in
                [48,96,192,768,]
            ] + [
                # === 多1空1动量
                {
                    # 策略名称。与strategy目录中的策略文件名保持一致。
                    "strategy": "Strategy_多1空1动量",
                    "offset_list": list(range(0, 1, 1)),
                    "hold_period": "1H",
                    "is_use_spot": False,
                    # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                    'cap_weight': 0.2,
                    'long_cap_weight': 1,
                    'short_cap_weight': 1,
                    'long_select_coin_num': 1,
                    'short_select_coin_num': 1,
                    # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                    "factor_list": [
                        ('MtmMean', False, 30, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                    ],
                    "filter_list": [
                        ('涨跌幅max', 24, 'val:<=0.2'),  # 因子名（和factors文件中相同），参数
                        ('Volume', 24, 'rank:<=60', False),
                    ],
                    "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                },
                {
                    # === 多1空1动量
                    # 策略名称。与strategy目录中的策略文件名保持一致。
                    "strategy": "Strategy_多1空1动量",
                    "offset_list": list(range(0, 1, 1)),
                    "hold_period": "1H",
                    "is_use_spot": False,
                    # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                    'cap_weight': 0.2,
                    'long_cap_weight': 1,
                    'short_cap_weight': 1,
                    'long_select_coin_num': 1,
                    'short_select_coin_num': 1,
                    # 选币因子信息列表，用于`2_选币_单offset.py`，`3_计算多offset资金曲线.py`共用计算资金曲线
                    "factor_list": [
                        ('MtmMean', False, 100, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                    ],
                    "filter_list": [
                        ('涨跌幅max', 24, 'val:<=0.2'),  # 因子名（和factors文件中相同），参数
                        ('Volume', 24, 'rank:<=60', False),
                    ],
                    "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                },

                # === 多1动量
                {
                    # 策略名称。与strategy目录中的策略文件名保持一致。
                    "strategy": "Strategy_多1动量",
                    "offset_list": list(range(0, 1, 1)),
                    "hold_period": "1H",
                    "is_use_spot": False,
                    # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                    'cap_weight': 0.2,
                    'long_cap_weight': 1,
                    'short_cap_weight': 0,
                    # 选币数量
                    'long_select_coin_num': 1,
                    'short_select_coin_num': 0,
                    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                    "factor_list": [
                        ('动量因子1', False, 1440, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                    ],
                    "filter_list": [
                        ('ILLQStd', 1440, 'pct:>0.8', True)
                    ],
                    "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                },
                {
                    # 策略名称。与strategy目录中的策略文件名保持一致。
                    "strategy": "Strategy_多1动量",
                    "offset_list": list(range(0, 1, 1)),
                    "hold_period": "1H",
                    "is_use_spot": False,
                    # 资金权重。程序会自动根据这个权重计算你的策略占比，具体可以看1.8的直播讲解
                    'cap_weight': 0.2,
                    'long_cap_weight': 1,
                    'short_cap_weight': 0,
                    # 选币数量
                    'long_select_coin_num': 1,
                    'short_select_coin_num': 0,
                    # 选币因子信息列表，用于2_选币_单offset.py，3_计算多offset资金曲线.py共用计算资金曲线
                    "factor_list": [
                        ('动量因子1', False, 1680, 1),  # 多头因子名（和factors文件中相同），排序方式，参数，权重。
                    ],
                    "filter_list": [
                        ('ILLQStd', 1680, 'pct:>0.8', True)
                    ],
                    "use_custom_func": False  # 使用系统内置因子计算、过滤函数
                },
            ]
        ),
    ]
